home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1999 / MacHack 1999.toast / The Hacks / AltiVec Effect / EffectFilter16.c < prev    next >
C/C++ Source or Header  |  1998-03-13  |  4KB  |  101 lines
  1. #include "BltMacros.h"
  2.  
  3. void EffectFilter16(BlitGlobals *glob);
  4. void EffectFilter16(BlitGlobals *glob)
  5. {
  6.     long    height = glob->height;                        // Local copy of the height of the sources and destination
  7.     UInt16    *srcA = glob->sources[0].srcBaseAddr;        // Local pointer to the first source image
  8.     UInt16    *srcB = glob->sources[1].srcBaseAddr;        // Local pointer to the second source image
  9.     UInt16    *dst = glob->dstBaseAddr;                    // Local pointer to the destination
  10.     long    srcABump;
  11.     long    srcBBump;
  12.     long    dstBump;
  13.     
  14.     float    dimMultiple;
  15.     
  16.     // Work out the source and destination "bumps". The rowBytes value gives you the number
  17.     // of bytes in each scanline of an image. This is not necessarily the same as the number
  18.     // of pixels in a scanline multiplied by the number of bytes each pixel occupies. When
  19.     // we copy pixels from source to destination, via our effect algorithm, we need to
  20.     // account for this discrepancy. The following lines lines pre-calculate the differences.
  21.     srcABump = glob->sources[0].srcRowBytes - (glob->width * 2);
  22.     srcBBump = glob->sources[1].srcRowBytes - (glob->width * 2);
  23.     dstBump  = glob->dstRowBytes - (glob->width * 2);
  24.     
  25.     // Depending on the direction we are currently fading in (fading down the first source,
  26.     // or fading up the second) pre-calculate the percentage brightness of the pixels of the
  27.     // destination. The dimValue always has the percentage and is set in the Begin function.
  28.     if (glob->direction)
  29.         dimMultiple = 1.0 - (((float) glob->dimValue) / 255.0);
  30.     else
  31.         dimMultiple = (((float) glob->dimValue) / 255.0);
  32.     
  33.     // Now, for every scanline in the source image we are dealing with...
  34.     while (height--)
  35.     {
  36.         long     width = glob->width;
  37.         
  38.         // ...iterate through every pixel in that scanline
  39.         while (width--)
  40.         {
  41.             UInt16     overlayPixel;
  42.             UInt16    preservedAlpha;
  43.             UInt16    newRed, newGreen, newBlue;
  44.             
  45.             // Depending on the direction, take the next pixel of the first or the
  46.             // second source.
  47.             if (glob->direction)
  48.             {
  49.                 // NOTE: You must not put the increment operator inside
  50.                 // the Get16 macro, or you will end up incrementing srcA
  51.                 // multiple times per pass.
  52.                 overlayPixel = Get16(srcA);
  53.                 srcA++;
  54.                 
  55.             }
  56.             else
  57.             {
  58.                 overlayPixel = Get16(srcB);
  59.                 srcB++;
  60.             }
  61.             // Call to BltMacros to ensure the pixel format is
  62.             // converted appropriately
  63.             cnv16SPFto16RG(overlayPixel);
  64.             
  65.             // Dim all of the RGB values by the same amount, but leave the alpha
  66.             // channel value unchanged
  67.             preservedAlpha = 0x8000 & overlayPixel;
  68.             
  69.             // The following lines extract the R, G and B channels of the source
  70.             // pixel, respectively. Each value is then multiplied by the pre-
  71.             // calculated dimMultiple, to produce the destination R, G and B
  72.             // channel values
  73.             newRed   = ((overlayPixel & 0x7C00) >> 10) * dimMultiple;
  74.             newGreen = ((overlayPixel & 0x03E0) >> 5) * dimMultiple;
  75.             newBlue  = ((overlayPixel & 0x001F) >> 0) * dimMultiple;
  76.             
  77.             // Re-assemble the A, R, G and B values into a 16-bit destination pixel
  78.             overlayPixel = (preservedAlpha) | (newRed << 10) | (newGreen << 5) | (newBlue << 0);
  79.             
  80.             // Set the destination pixel to be the dimmed version of the
  81.             // appropriate source pixel. The dimmed pixel value is first
  82.             // passed through the BltMacro to ensure the correct pixel
  83.             // format conversion is performed
  84.             cnv16RGto16DPF(overlayPixel);
  85.             Set16(dst,overlayPixel);
  86.             dst++;
  87.         }
  88.  
  89.         // Bump the source and destination pointers we are using, to avoid
  90.         // problems when moving from one scanline to the next
  91.         if (glob->direction)
  92.             srcA = (void *)(((Ptr) srcA) + srcABump);
  93.         else
  94.             srcB = (void *)(((Ptr) srcB) + srcBBump);
  95.         
  96.         dst = (void *)(((Ptr) dst) + dstBump);
  97.     }
  98.     
  99.     // And we're done...
  100.     
  101. } // DrawEffectFrameEffect16Bit